home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / gxpath.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  12.6 KB  |  327 lines
  1. /* Copyright (C) 1989, 1995, 1996, 1997, 1998, 1999 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: gxpath.h,v 1.2 2000/09/19 19:00:39 lpd Exp $ */
  20. /* Fixed-point path procedures */
  21. /* Requires gxfixed.h */
  22.  
  23. #ifndef gxpath_INCLUDED
  24. #  define gxpath_INCLUDED
  25.  
  26. #include "gscpm.h"
  27. #include "gslparam.h"
  28. #include "gspenum.h"
  29. #include "gsrect.h"
  30.  
  31. /* The routines and types in this interface use */
  32. /* device, rather than user, coordinates, and fixed-point, */
  33. /* rather than floating, representation. */
  34.  
  35. /* Opaque type for a path */
  36. #ifndef gx_path_DEFINED
  37. #  define gx_path_DEFINED
  38. typedef struct gx_path_s gx_path;
  39. #endif
  40.  
  41. /* Define the two insideness rules */
  42. #define gx_rule_winding_number (-1)
  43. #define gx_rule_even_odd 1
  44.  
  45. /* Define 'notes' that describe the role of a path segment. */
  46. /* These are only for internal use; a normal segment's notes are 0. */
  47. typedef enum {
  48.     sn_none = 0,
  49.     sn_not_first = 1,        /* segment is in curve/arc and not first */
  50.     sn_from_arc = 2        /* segment is part of an arc */
  51. } segment_notes;
  52.  
  53. /* Debugging routines */
  54. #ifdef DEBUG
  55. void gx_dump_path(P2(const gx_path *, const char *));
  56. void gx_path_print(P1(const gx_path *));
  57. #endif
  58.  
  59. /* Path memory management */
  60.  
  61. /*
  62.  * Path memory management is unfortunately a little tricky.  The
  63.  * implementation details are in gzpath.h: we only present the API here.
  64.  *
  65.  * Path objects per se may be allocated in 3 different ways: on the
  66.  * C stack, as separate objects in the heap, or (for the graphics state
  67.  * only) contained in a larger heap-allocated object.
  68.  *
  69.  * Any number of paths may share segments.  The segments are stored in
  70.  * their own, reference-counted object, and are freed when there are no
  71.  * more references to that object.
  72.  */
  73.  
  74. /*
  75.  * Allocate a path on the heap, and initialize it.  If shared is NULL,
  76.  * allocate a segments object; if shared is an existing path, share its
  77.  * segments.
  78.  */
  79. gx_path *gx_path_alloc_shared(P3(const gx_path * shared, gs_memory_t * mem,
  80.                  client_name_t cname));
  81.  
  82. #define gx_path_alloc(mem, cname)\
  83.   gx_path_alloc_shared(NULL, mem, cname)
  84. /*
  85.  * Initialize a path contained in an already-heap-allocated object,
  86.  * optionally allocating its segments.
  87.  */
  88. int gx_path_init_contained_shared(P4(gx_path * ppath, const gx_path * shared,
  89.                    gs_memory_t * mem, client_name_t cname));
  90.  
  91. #define gx_path_alloc_contained(ppath, mem, cname)\
  92.   gx_path_init_contained_shared(ppath, NULL, mem, cname)
  93. /*
  94.  * Initialize a stack-allocated path.  This doesn't allocate anything,
  95.  * but may still share the segments.  Note that it returns an error if
  96.  * asked to share the segments of another local path.
  97.  */
  98. int gx_path_init_local_shared(P3(gx_path * ppath, const gx_path * shared,
  99.                  gs_memory_t * mem));
  100.  
  101. #define gx_path_init_local(ppath, mem)\
  102.   (void)gx_path_init_local_shared(ppath, NULL, mem)    /* can't fail */
  103.  
  104. /*
  105.  * Ensure that a path owns its segments, by copying the segments if
  106.  * they currently have multiple references.
  107.  */
  108. int gx_path_unshare(P1(gx_path * ppath));
  109.  
  110. /*
  111.  * Free a path by releasing its segments if they have no more references.
  112.  * This also frees the path object iff it was allocated by gx_path_alloc.
  113.  */
  114. void gx_path_free(P2(gx_path * ppath, client_name_t cname));
  115.  
  116. /*
  117.  * Assign one path to another, adjusting reference counts appropriately.
  118.  * Note that this requires that segments of the two paths (but not the path
  119.  * objects themselves) were allocated with the same allocator.  Note also
  120.  * that if ppfrom is stack-allocated, ppto is not, and ppto's segments are
  121.  * currently shared, gx_path_assign must do the equivalent of a
  122.  * gx_path_new(ppto), which allocates a new segments object for ppto.
  123.  */
  124. int gx_path_assign_preserve(P2(gx_path * ppto, gx_path * ppfrom));
  125.  
  126. /*
  127.  * Assign one path to another and free the first path at the same time.
  128.  * (This may do less work than assign_preserve + free.)
  129.  */
  130. int gx_path_assign_free(P2(gx_path * ppto, gx_path * ppfrom));
  131.  
  132. /* Path constructors */
  133. /* Note that all path constructors have an implicit initial gx_path_unshare. */
  134.  
  135. int gx_path_new(P1(gx_path *)),
  136.     gx_path_add_point(P3(gx_path *, fixed, fixed)),
  137.     gx_path_add_relative_point(P3(gx_path *, fixed, fixed)),
  138.     gx_path_add_line_notes(P4(gx_path *, fixed, fixed, segment_notes)),
  139.     gx_path_add_lines_notes(P4(gx_path *, const gs_fixed_point *, int, segment_notes)),
  140.     gx_path_add_rectangle(P5(gx_path *, fixed, fixed, fixed, fixed)),
  141.     gx_path_add_char_path(P3(gx_path *, gx_path *, gs_char_path_mode)),
  142.     gx_path_add_curve_notes(P8(gx_path *, fixed, fixed, fixed, fixed, fixed, fixed, segment_notes)),
  143.     gx_path_add_partial_arc_notes(P7(gx_path *, fixed, fixed, fixed, fixed, floatp, segment_notes)),
  144.     gx_path_add_path(P2(gx_path *, gx_path *)),
  145.     gx_path_close_subpath_notes(P2(gx_path *, segment_notes)),
  146.       /* We have to remove the 'subpath' from the following name */
  147.       /* to keep it unique in the first 23 characters. */
  148.     gx_path_pop_close_notes(P2(gx_path *, segment_notes));
  149.  
  150. /*
  151.  * The last argument to gx_path_add_partial_arc is a fraction for computing
  152.  * the curve parameters.  Here is the correct value for quarter-circles.
  153.  * (stroke uses this to draw round caps and joins.)
  154.  */
  155. #define quarter_arc_fraction 0.55228474983079334
  156. /*
  157.  * Backward-compatible constructors that don't take a notes argument.
  158.  */
  159. #define gx_path_add_line(ppath, x, y)\
  160.   gx_path_add_line_notes(ppath, x, y, sn_none)
  161. #define gx_path_add_lines(ppath, pts, count)\
  162.   gx_path_add_lines_notes(ppath, pts, count, sn_none)
  163. #define gx_path_add_curve(ppath, x1, y1, x2, y2, x3, y3)\
  164.   gx_path_add_curve_notes(ppath, x1, y1, x2, y2, x3, y3, sn_none)
  165. #define gx_path_add_partial_arc(ppath, x3, y3, xt, yt, fraction)\
  166.   gx_path_add_partial_arc_notes(ppath, x3, y3, xt, yt, fraction, sn_none)
  167. #define gx_path_close_subpath(ppath)\
  168.   gx_path_close_subpath_notes(ppath, sn_none)
  169. #define gx_path_pop_close_subpath(ppath)\
  170.   gx_path_pop_close_notes(ppath, sn_none)
  171.  
  172. /* Path accessors */
  173.  
  174. gx_path *gx_current_path(P1(const gs_state *));
  175. int gx_path_current_point(P2(const gx_path *, gs_fixed_point *)),
  176.     gx_path_bbox(P2(gx_path *, gs_fixed_rect *));
  177. int gx_path_subpath_start_point(P2(const gx_path *, gs_fixed_point *));
  178. bool gx_path_has_curves(P1(const gx_path *)),
  179.     gx_path_is_void(P1(const gx_path *)),    /* no segments */
  180.     gx_path_is_null(P1(const gx_path *)),    /* nothing at all */
  181.     gx_path_is_monotonic(P1(const gx_path *));
  182. typedef enum {
  183.     prt_none = 0,
  184.     prt_open = 1,        /* only 3 sides */
  185.     prt_fake_closed = 2,    /* 4 lines, no closepath */
  186.     prt_closed = 3        /* 3 or 4 lines + closepath */
  187. } gx_path_rectangular_type;
  188.  
  189. gx_path_rectangular_type
  190. gx_path_is_rectangular(P2(const gx_path *, gs_fixed_rect *));
  191.  
  192. #define gx_path_is_rectangle(ppath, pbox)\
  193.   (gx_path_is_rectangular(ppath, pbox) != prt_none)
  194. /* Inline versions of the above */
  195. #define gx_path_is_null_inline(ppath)\
  196.   (gx_path_is_void(ppath) && !path_position_valid(ppath))
  197.  
  198. /* Path transformers */
  199.  
  200. /* gx_path_copy_reducing is internal. */
  201. typedef enum {
  202.     pco_none = 0,
  203.     pco_monotonize = 1,        /* make curves monotonic */
  204.     pco_accurate = 2,        /* flatten with accurate tangents at ends */
  205.     pco_for_stroke = 4        /* flatten taking line width into account */
  206. } gx_path_copy_options;
  207. /* The imager state is only needed when flattening for stroke. */
  208. #ifndef gs_imager_state_DEFINED
  209. #  define gs_imager_state_DEFINED
  210. typedef struct gs_imager_state_s gs_imager_state;
  211. #endif
  212. int gx_path_copy_reducing(P5(const gx_path * ppath_old, gx_path * ppath_new,
  213.                  fixed fixed_flatness, const gs_imager_state *pis,
  214.                  gx_path_copy_options options));
  215.  
  216. #define gx_path_copy(old, new)\
  217.   gx_path_copy_reducing(old, new, max_fixed, NULL, pco_none)
  218. #define gx_path_add_flattened(old, new, flatness)\
  219.   gx_path_copy_reducing(old, new, float2fixed(flatness), NULL, pco_none)
  220. #define gx_path_add_flattened_accurate(old, new, flatness, accurate)\
  221.   gx_path_copy_reducing(old, new, float2fixed(flatness), NULL,\
  222.             (accurate ? pco_accurate : pco_none))
  223. #define gx_path_add_flattened_for_stroke(old, new, flatness, pis)\
  224.   gx_path_copy_reducing(old, new, float2fixed(flatness), pis,\
  225.             (pis->accurate_curves ?\
  226.              pco_accurate | pco_for_stroke : pco_for_stroke))
  227. #define gx_path_add_monotonized(old, new)\
  228.   gx_path_copy_reducing(old, new, max_fixed, NULL, pco_monotonize)
  229. int gx_path_add_dash_expansion(P3(const gx_path * /*old*/, gx_path * /*new*/,
  230.                   const gs_imager_state *)),
  231.       gx_path_copy_reversed(P2(const gx_path * /*old*/, gx_path * /*new*/)),
  232.       gx_path_translate(P3(gx_path *, fixed, fixed)),
  233.       gx_path_scale_exp2_shared(P4(gx_path *ppath, int log2_scale_x,
  234.                    int log2_scale_y, bool segments_shared));
  235. void gx_point_scale_exp2(P3(gs_fixed_point *, int, int)),
  236.       gx_rect_scale_exp2(P3(gs_fixed_rect *, int, int));
  237.  
  238. /* Path enumerator */
  239.  
  240. /* This interface does not make a copy of the path. */
  241. /* Do not use gs_path_enum_cleanup with this interface! */
  242. int gx_path_enum_init(P2(gs_path_enum *, const gx_path *));
  243. int gx_path_enum_next(P2(gs_path_enum *, gs_fixed_point[3]));    /* 0 when done */
  244.  
  245. segment_notes
  246. gx_path_enum_notes(P1(const gs_path_enum *));
  247. bool gx_path_enum_backup(P1(gs_path_enum *));
  248.  
  249. /* ------ Clipping paths ------ */
  250.  
  251. /* Opaque type for a clipping path */
  252. #ifndef gx_clip_path_DEFINED
  253. #  define gx_clip_path_DEFINED
  254. typedef struct gx_clip_path_s gx_clip_path;
  255. #endif
  256.  
  257. /* Graphics state clipping */
  258. int gx_clip_to_rectangle(P2(gs_state *, gs_fixed_rect *));
  259. int gx_clip_to_path(P1(gs_state *));
  260. int gx_default_clip_box(P2(const gs_state *, gs_fixed_rect *));
  261. int gx_effective_clip_path(P2(gs_state *, gx_clip_path **));
  262.  
  263. /* Opaque type for a clip list. */
  264. #ifndef gx_clip_list_DEFINED
  265. #  define gx_clip_list_DEFINED
  266. typedef struct gx_clip_list_s gx_clip_list;
  267. #endif
  268.  
  269. /* Opaque type for a clipping path enumerator. */
  270. typedef struct gs_cpath_enum_s gs_cpath_enum;
  271.  
  272. /*
  273.  * Provide similar memory management for clip paths to what we have for
  274.  * paths (see above for details).
  275.  */
  276. gx_clip_path *gx_cpath_alloc_shared(P3(const gx_clip_path * shared,
  277.                        gs_memory_t * mem,
  278.                        client_name_t cname));
  279.  
  280. #define gx_cpath_alloc(mem, cname)\
  281.   gx_cpath_alloc_shared(NULL, mem, cname)
  282. int gx_cpath_init_contained_shared(P4(gx_clip_path * pcpath,
  283.                       const gx_clip_path * shared,
  284.                       gs_memory_t * mem,
  285.                       client_name_t cname));
  286.  
  287. #define gx_cpath_alloc_contained(pcpath, mem, cname)\
  288.   gx_cpath_init_contained_shared(pcpath, NULL, mem, cname)
  289. int gx_cpath_init_local_shared(P3(gx_clip_path * pcpath,
  290.                   const gx_clip_path * shared,
  291.                   gs_memory_t * mem));
  292.  
  293. #define gx_cpath_init_local(pcpath, mem)\
  294.   (void)gx_cpath_init_local_shared(pcpath, NULL, mem)    /* can't fail */
  295. int gx_cpath_unshare(P1(gx_clip_path * pcpath));
  296. void gx_cpath_free(P2(gx_clip_path * pcpath, client_name_t cname));
  297. int gx_cpath_assign_preserve(P2(gx_clip_path * pcpto, gx_clip_path * pcpfrom));
  298. int gx_cpath_assign_free(P2(gx_clip_path * pcpto, gx_clip_path * pcpfrom));
  299.  
  300. /* Clip path constructors and accessors */
  301.  
  302. int
  303.     gx_cpath_reset(P1(gx_clip_path *)),        /* from_rectangle ((0,0),(0,0)) */
  304.     gx_cpath_from_rectangle(P2(gx_clip_path *, gs_fixed_rect *)),
  305.     gx_cpath_clip(P4(gs_state *, gx_clip_path *, /*const*/ gx_path *, int)),
  306.     gx_cpath_intersect(P4(gx_clip_path *, /*const*/ gx_path *, int,
  307.               gs_imager_state *)),
  308.     gx_cpath_scale_exp2_shared(P5(gx_clip_path *pcpath, int log2_scale_x,
  309.                   int log2_scale_y, bool list_shared,
  310.                   bool segments_shared)),
  311.     gx_cpath_to_path(P2(gx_clip_path *, gx_path *));
  312. bool
  313.     gx_cpath_inner_box(P2(const gx_clip_path *, gs_fixed_rect *)),
  314.     gx_cpath_outer_box(P2(const gx_clip_path *, gs_fixed_rect *)),
  315.     gx_cpath_includes_rectangle(P5(const gx_clip_path *, fixed, fixed,
  316.                    fixed, fixed));
  317.  
  318. /* Enumerate a clipping path.  This interface does not copy the path. */
  319. /* However, it does write into the path's "visited" flags. */
  320. int gx_cpath_enum_init(P2(gs_cpath_enum *, gx_clip_path *));
  321. int gx_cpath_enum_next(P2(gs_cpath_enum *, gs_fixed_point[3]));        /* 0 when done */
  322.  
  323. segment_notes
  324. gx_cpath_enum_notes(P1(const gs_cpath_enum *));
  325.  
  326. #endif /* gxpath_INCLUDED */
  327.